Aminet 51/Aminet 51 (2002)(GTI - Schatztruhe)[!][Oct 2002].iso/Aminet/dev/c/minigl.lha/MiniGL/src/vertexelements.c

C/C++ Source or Header | 2002-06-02 | 66.0 KB | 3,178 lines

//Note: tristrip backface-culling is disabled for clipping events because of an unidentified bug

#include "sysinc.h"
#include "vertexarray.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>


/*
** glDrawElements pipeline by Christian 'Surgeon' Michael
** Thanks to Olivier Fabre for bug-hunting
**
** major revision 05-07 april 2002:
** optimized path for GL_EXT_compiled_vertex_array
**
*/

extern void TMA_Start(LockTimeHandle *handle);
extern GLboolean TMA_Check(LockTimeHandle *handle);
extern void fog_Set(GLcontext context);

void GLLockArrays(GLcontext context, GLuint first, GLsizei count);
void GLUnLockArrays(GLcontext context);

extern void AE_ClipPoly(GLcontext context, PolyBuffer *out, int clipstart, ULONG or_codes);

extern void m_CombineMatrices(GLcontext context);

extern GLboolean DecideFrontface(GLcontext context, const MGLVertex *a, const MGLVertex *b, const MGLVertex *c, const int sign);

extern Convfn Convert;

GLboolean Clip_Volume_Bypass = GL_FALSE; //for compiled arrays

//NYI:

void E_DrawPoints        (GLcontext context, const int count, const UWORD *idx);
void E_DrawLines         (GLcontext context, const int count, const UWORD *idx);
void E_DrawLineStrip     (GLcontext context, const int count, const UWORD *idx);
void E_DrawLineLoop      (GLcontext context, const int count, const UWORD *idx);

void E_DrawQuads         (GLcontext context, const int count, const UWORD *idx);
void E_DrawQuadStrip     (GLcontext context, const int count, const UWORD *idx);

//implemented:


void E_DrawTriFan       (GLcontext context, const int count, UWORD *idx);

void E_DrawPolygon       (GLcontext context, const int count, UWORD *idx);

void E_DrawTriStrip       (GLcontext context, const int count, const UWORD *idx);

void E_DrawTriangles     (GLcontext context, const int count, const UWORD *idx);

void E_DrawFlatFan       (GLcontext context, const int count, const UWORD *idx);

static PolyBuffer clip[MGL_MAXVERTS>>2];
static PolyBuffer polys[MGL_MAXVERTS>>2];


INLINE GLboolean E_CheckTri(GLcontext context, const MGLVertex *a, const MGLVertex *b, const MGLVertex *c, const int sign)
{
    float area;
    float x1,y1;
    float x2,y2;

    x1 = b->v.x - a->v.x;
    y1 = b->v.y - a->v.y;
    x2 = c->v.x - a->v.x;
    y2 = c->v.y - a->v.y;

    area = y2*x1 - x2*y1;

    if(sign > 0)
        area = -area;

    if(area < context->MinTriArea)
        return GL_FALSE;
    else
        return GL_TRUE;
}


#define OF_11 0
#define OF_12 4
#define OF_13 8
#define OF_14 12

#define OF_21 1
#define OF_22 5
#define OF_23 9
#define OF_24 13

#define OF_31 2
#define OF_32 6
#define OF_33 10
#define OF_34 14

#define OF_41 3
#define OF_42 7
#define OF_43 11
#define OF_44 15


void TransformIndex(GLcontext context, const int size, const UWORD *idx)
{
   int i;

   #define a(x) (context->CombinedMatrix.v[OF_##x])

   if(context->ArrayPointer.FixpointTrans == GL_TRUE)
   {
    static int m[16];
    int tx,ty,tz,tw;
    int x,y,z;
    int cw;
      int *vp;
    ULONG local_outcode;
    UBYTE *vpointer;
    MGLVertex *v;
    int stride;
    const float fix2float = 1.f/32768.f;

      #define CLIP_EPS ((int)((1e-7)*32768.f))

     #define b(x) (m[OF_##x])

      if(context->CombinedValid == GL_FALSE)
    {
    const float float2fix = 32768.f;

            m_CombineMatrices(context);

        b(11)=(int)(a(11)*float2fix);
        b(12)=(int)(a(12)*float2fix);
        b(13)=(int)(a(13)*float2fix);
        b(14)=(int)(a(14)*float2fix);
        b(21)=(int)(a(21)*float2fix);
        b(22)=(int)(a(22)*float2fix);
        b(23)=(int)(a(23)*float2fix);
        b(24)=(int)(a(24)*float2fix);
        b(31)=(int)(a(31)*float2fix);
        b(32)=(int)(a(32)*float2fix);
        b(33)=(int)(a(33)*float2fix);
        b(34)=(int)(a(34)*float2fix);
        b(41)=(int)(a(41)*float2fix);
        b(42)=(int)(a(42)*float2fix);
        b(43)=(int)(a(43)*float2fix);
        b(44)=(int)(a(44)*float2fix);
    }

     stride = context->ArrayPointer.vertexstride;

     i = size-1;
     do
     {
     v = &(context->VertexBuffer[idx[i]]);
     vpointer = (context->ArrayPointer.verts + idx[i]*stride);

      vp = (int *)vpointer;

      x = vp[0];
      y = vp[1];
      z = vp[2];

    //pipelined transformations

       tx  = x*b(11);
       ty  = x*b(21);
       tz  = x*b(31);
       tw  = x*b(41);

    tx += y*b(12);
    ty += y*b(22);
    tz += y*b(32);
    tw += y*b(42);

    tx += z*b(13);
    ty += z*b(23);
    tz += z*b(33);
    tw += z*b(43);

    tx += b(14);
    ty += b(24);
    tz += b(34);
    tw += b(44);

    local_outcode = 0;

        if (tw < CLIP_EPS )
      {
                local_outcode |= MGL_CLIP_NEGW;
      }
        if (-tw > tx)
        {
                local_outcode |= MGL_CLIP_LEFT;
        }
        else if (tx > tw)
        {
                local_outcode |= MGL_CLIP_RIGHT;
        }

        if (-tw > ty)
        {
                local_outcode |= MGL_CLIP_BOTTOM;
        }
        else if (ty > tw)
        {
                local_outcode |= MGL_CLIP_TOP;
        }

        if (-tw > tz)
        {
                local_outcode |= MGL_CLIP_BACK;
        }
        else if (tz > tw)
        {
                local_outcode |= MGL_CLIP_FRONT;
        }

    v->bx = (float)tx*fix2float;
    v->by = (float)ty*fix2float;
    v->bz = (float)tz*fix2float;
    v->bw = (float)tw*fix2float;

      v->outcode = local_outcode;

     } while (i--);

    #undef b
    #undef CLIP_EPS
   }
   else
   {
      float a11,a12,a13,a14;
      float a21,a22,a23,a24;
      float a31,a32,a33,a34;
      float a41,a42,a43,a44;
      float *vp;
      float cw;
      float x,y,z;
    ULONG local_outcode;
    UBYTE *vpointer;
    MGLVertex *v;
    int stride;

      #define CLIP_EPS (1e-7)

     if(context->CombinedValid == GL_FALSE)
            m_CombineMatrices(context);

     a11=a(11); a12=a(12); a13=a(13); a14=a(14);
     a21=a(21); a22=a(22); a23=a(23); a24=a(24);
     a31=a(31); a32=a(32); a33=a(33); a34=a(34);
     a41=a(41); a42=a(42); a43=a(43); a44=a(44);

     stride = context->ArrayPointer.vertexstride;

     i = size-1;

     do
     {
     v = &(context->VertexBuffer[idx[i]]);
     vpointer = (context->ArrayPointer.verts + idx[i]*stride);
     vp = (float *)vpointer;

        x = vp[0];
        y = vp[1];
        z = vp[2];

        v->bx = a11*x + a12*y + a13*z + a14;
        v->by = a21*x + a22*y + a23*z + a24;
        v->bz = a31*x + a32*y + a33*z + a34;
        v->bw = a41*x + a42*y + a43*z + a44;

        cw = v->bw;
        local_outcode = 0;

        if (cw < CLIP_EPS )
                local_outcode |= MGL_CLIP_NEGW;

        if (-cw > v->bx)
        {
                local_outcode |= MGL_CLIP_LEFT;
        }
        else if (v->bx > cw)
        {
                local_outcode |= MGL_CLIP_RIGHT;
        }

        if (-cw > v->by)
        {
                local_outcode |= MGL_CLIP_BOTTOM;
        }
        else if (v->by > cw)
        {
                local_outcode |= MGL_CLIP_TOP;
        }

        if (-cw > v->bz)
        {
                local_outcode |= MGL_CLIP_BACK;
        }
        else if (v->bz > cw)
        {
                local_outcode |= MGL_CLIP_FRONT;
        }

        v->outcode = local_outcode;

     } while (i--);

     #undef CLIP_EPS
     #undef a
   }
}


//following 5 functions are called from glLockArrays
//05-04-02    returns number of onscreen verts

INLINE ULONG TransformRange(GLcontext context, const int first, const int size)
{
   int i;
   ULONG border;

   #define a(x) (context->CombinedMatrix.v[OF_##x])

   if(context->ArrayPointer.FixpointTrans == GL_TRUE)
   {
    static int m[16];
    int tx,ty,tz,tw;
    int x,y,z;
    int cw;
      int *vp;
    ULONG local_outcode;
    UBYTE *vpointer;
    MGLVertex *v;
    int stride;

      #define CLIP_EPS ((int)((1e-7)*32768.f))

     #define b(x) (m[OF_##x])

      if(context->CombinedValid == GL_FALSE)
    {
    const float float2fix = 32768.f;

            m_CombineMatrices(context);

        b(11)=(int)(a(11)*float2fix);
        b(12)=(int)(a(12)*float2fix);
        b(13)=(int)(a(13)*float2fix);
        b(14)=(int)(a(14)*float2fix);
        b(21)=(int)(a(21)*float2fix);
        b(22)=(int)(a(22)*float2fix);
        b(23)=(int)(a(23)*float2fix);
        b(24)=(int)(a(24)*float2fix);
        b(31)=(int)(a(31)*float2fix);
        b(32)=(int)(a(32)*float2fix);
        b(33)=(int)(a(33)*float2fix);
        b(34)=(int)(a(34)*float2fix);
        b(41)=(int)(a(41)*float2fix);
        b(42)=(int)(a(42)*float2fix);
        b(43)=(int)(a(43)*float2fix);
        b(44)=(int)(a(44)*float2fix);
    }

     stride = context->ArrayPointer.vertexstride;
     vpointer = (context->ArrayPointer.verts + first*stride);

     v = &(context->VertexBuffer[first]);

     border = 0;
     i = size;

     do
     {

      vp = (int *)vpointer;

      x = vp[0];
      y = vp[1];
      z = vp[2];

    //pipelined transformations

       tx  = x*b(11);
       ty  = x*b(21);
       tz  = x*b(31);
       tw  = x*b(41);

    tx += y*b(12);
    ty += y*b(22);
    tz += y*b(32);
    tw += y*b(42);

    tx += z*b(13);
    ty += z*b(23);
    tz += z*b(33);
    tw += z*b(43);

    tx += b(14);
    ty += b(24);
    tz += b(34);
    tw += b(44);

    local_outcode = 0;

        if (tw < CLIP_EPS )
      {
                local_outcode |= MGL_CLIP_NEGW;
      }
        if (-tw > tx)
        {
                local_outcode |= MGL_CLIP_LEFT;
        }
        else if (tx > tw)
        {
                local_outcode |= MGL_CLIP_RIGHT;
        }

        if (-tw > ty)
        {
                local_outcode |= MGL_CLIP_BOTTOM;
        }
        else if (ty > tw)
        {
                local_outcode |= MGL_CLIP_TOP;
        }

        if (-tw > tz)
        {
                local_outcode |= MGL_CLIP_BACK;
        }
        else if (tz > tw)
        {
                local_outcode |= MGL_CLIP_FRONT;
        }

    border |= local_outcode;

      v->outcode = local_outcode;

    v->bx = (float)tx;
    v->by = (float)ty;
    v->bz = (float)tz;
    v->bw = (float)tw;

     v++; vpointer += stride;

     } while (--i);

    #undef b
    #undef CLIP_EPS
   }
   else
   {
     float a11,a12,a13,a14;
     float a21,a22,a23,a24;
     float a31,a32,a33,a34;
     float a41,a42,a43,a44;
     float *vp;
     float cw;
     float x,y,z;
     ULONG local_outcode;
     UBYTE *vpointer;
     MGLVertex *v;
     int stride;

     #define CLIP_EPS (1e-7)

     if(context->CombinedValid == GL_FALSE)
            m_CombineMatrices(context);

     a11=a(11); a12=a(12); a13=a(13); a14=a(14);
     a21=a(21); a22=a(22); a23=a(23); a24=a(24);
     a31=a(31); a32=a(32); a33=a(33); a34=a(34);
     a41=a(41); a42=a(42); a43=a(43); a44=a(44);

     stride = context->ArrayPointer.vertexstride;
     vpointer = (context->ArrayPointer.verts + first*stride);

     v = &(context->VertexBuffer[first]);

     i = size;

     do
     {
        vp = (float *)vpointer;

        x = vp[0];
        y = vp[1];
        z = vp[2];

        v->bx = a11*x + a12*y + a13*z + a14;
        v->by = a21*x + a22*y + a23*z + a24;
        v->bz = a31*x + a32*y + a33*z + a34;
        v->bw = a41*x + a42*y + a43*z + a44;

     v++; vpointer += stride;

     } while (--i);

     v = &context->VertexBuffer[first];
     i = size;
     border = 0;

     do
     {
        cw = v->bw;
        local_outcode = 0;

        if (cw < CLIP_EPS )
      {
                local_outcode |= MGL_CLIP_NEGW;
      }
        if (-cw > v->bx)
        {
                local_outcode |= MGL_CLIP_LEFT;
        }
        else if (v->bx > cw)
        {
                local_outcode |= MGL_CLIP_RIGHT;
        }

        if (-cw > v->by)
        {
                local_outcode |= MGL_CLIP_BOTTOM;
        }
        else if (v->by > cw)
        {
                local_outcode |= MGL_CLIP_TOP;
        }

        if (-cw > v->bz)
        {
                local_outcode |= MGL_CLIP_BACK;
        }
        else if (v->bz > cw)
        {
                local_outcode |= MGL_CLIP_FRONT;
        }

        v->outcode = local_outcode;

    border |= local_outcode;

      v++;
      } while (--i);

    #undef CLIP_EPS
   }

   #undef a

   return border;
}


INLINE void ProjectRange(GLcontext context, const int first, const int size)
{
   int i, stride;
   float x,y,z,w;

   UBYTE *pointer;
   float *wa;
   float az;

   if(context->ZOffset_State == GL_TRUE)
   {
       az = context->az + context->ZOffset;
   }
   else
   {
    az = context->az;
   }

   if(!(context->ClientState & GLCS_TEXTURE))
   {
       MGLVertex *v = &context->VertexBuffer[first];
      i = size;

      do
      {
           x = v->bx;
           y = v->by;
           z = v->bz;
           w = 1.0 / v->bw;

           v->bx = context->ax + x * w * context->sx;
           v->by = context->ay - y * w * context->sy;
           v->bz = az + z * w * context->sz;

      v++;

      } while (--i);
   }
   else if (context->ArrayPointer.FixpointTrans == GL_TRUE)
   {
       MGLVertex *v = &context->VertexBuffer[first];
       stride = context->ArrayPointer.texcoordstride;
       pointer = (UBYTE*)context->WBuffer + first * stride;


      i = size;

      do
      {
           x = v->bx;
           y = v->by;
           z = v->bz;
           w = 1.0 / v->bw;

           v->bx = context->ax + x * w * context->sx;
           v->by = context->ay - y * w * context->sy;
           v->bz = az + z * w * context->sz;

         w *= 32768.f;
         wa = (float*)pointer;
         *wa = w;

      v++;
      pointer += stride;

      } while (--i);
   }
   else
   {
       MGLVertex *v = &context->VertexBuffer[first];
       stride = context->ArrayPointer.texcoordstride;
       pointer = (UBYTE*)context->WBuffer + first * stride;


      i = size;

      do
      {
           x = v->bx;
           y = v->by;
           z = v->bz;
           w = 1.0 / v->bw;

           v->bx = context->ax + x * w * context->sx;
           v->by = context->ay - y * w * context->sy;
           v->bz = az + z * w * context->sz;

         wa = (float*)pointer;
         *wa = w;

      v++;
      pointer += stride;

      } while (--i);
   }
}


INLINE void ProjectRangeByOutcode(GLcontext context, const int first, const int size)
{
   int i, stride;
   float x,y,z,w;

   UBYTE *pointer;
   float *wa;
   float az;

   if(context->ZOffset_State == GL_TRUE)
   {
       az = context->az + context->ZOffset;
   }
   else
   {
    az = context->az;
   }

   if(context->ArrayPointer.FixpointTrans == GL_TRUE)
   {
    const float fix2float = 1.f/32768.f;

    if(!(context->ClientState & GLCS_TEXTURE))
    {
         MGLVertex *v = &context->VertexBuffer[first];

         for (i=0; i<size; i++, v++)
         {
           x = v->bx;
           y = v->by;
           z = v->bz;
           w = v->bw;

         v->bx = fix2float * x;
         v->by = fix2float * y;
         v->bz = fix2float * z;
         v->bw = fix2float * w;

         if(v->outcode & context->ClipFlags)
        continue;

         w = 1.0 / w;

         v->v.x = context->ax + x * w * context->sx;
         v->v.y = context->ay - y * w * context->sy;
         v->v.z = az + z * w * context->sz;
         }
    }
    else
    {
         MGLVertex *v = &context->VertexBuffer[first];
         stride = context->ArrayPointer.texcoordstride;
         pointer = (UBYTE*)context->WBuffer + first * stride;

         for (i=0; i<size; i++, v++, pointer += stride)
         {
           x = v->bx;
           y = v->by;
           z = v->bz;
           w = v->bw;

         v->bx = fix2float * x;
         v->by = fix2float * y;
         v->bz = fix2float * z;
         v->bw = fix2float * w;

         if(v->outcode & context->ClipFlags)
        continue;

           w = 1.0 / w;

          v->v.x = context->ax + x * w * context->sx;
         v->v.y = context->ay - y * w * context->sy;
         v->v.z = az + z * w * context->sz;

         w *= 32768.f;
         wa = (float*)pointer;
         v->v.w = w;
         *wa = w;
         }
    }
   }
   else if(!(context->ClientState & GLCS_TEXTURE))
   {
        MGLVertex *v = &context->VertexBuffer[first];

      for (i=0; i<size; i++, v++)
      {
         if(v->outcode & context->ClipFlags)
        continue;

           x = v->bx;
           y = v->by;
           z = v->bz;
           w = 1.0 / v->bw;

         v->v.x = context->ax + x * w * context->sx;
         v->v.y = context->ay - y * w * context->sy;
         v->v.z = az + z * w * context->sz;
       }
   }
   else
   {
       MGLVertex *v = &context->VertexBuffer[first];
       stride = context->ArrayPointer.texcoordstride;
       pointer = (UBYTE*)context->WBuffer + first * stride;

      for (i=0; i<size; i++, v++, pointer += stride)
      {
         if(v->outcode & context->ClipFlags)
        continue;

           x = v->bx;
           y = v->by;
           z = v->bz;
           w = 1.0 / v->bw;

         v->v.x = context->ax + x * w * context->sx;
         v->v.y = context->ay - y * w * context->sy;
         v->v.z = az + z * w * context->sz;

         v->v.w = w;

         wa = (float*)pointer;
         *wa = w;
      }
   }
}


INLINE void E_ToScreenArray(GLcontext context, const int count, const UWORD *idx)
{
   int i, stride;
   float x,y,z,w;

   UBYTE *pointer;
   float *wa;
   float az;

   if(context->ZOffset_State == GL_TRUE)
   {
       az = context->az + context->ZOffset;
   }
   else
   {
    az = context->az;
   }

   if(!(context->ClientState & GLCS_TEXTURE))
   {
      i = 0;

      do
      {
       MGLVertex *v = &context->VertexBuffer[idx[i]];

           x = v->bx;
           y = v->by;
           z = v->bz;
           w = 1.0 / v->bw;

           v->v.x = context->ax + x * w * context->sx;
           v->v.y = context->ay - y * w * context->sy;
           v->v.z = az + z * w * context->sz;

      i++;
      } while (i < count);
   }
   else
   {
       stride = context->ArrayPointer.texcoordstride;

      i = 0;

      do
      {
       MGLVertex *v = &context->VertexBuffer[idx[i]];

           x = v->bx;
           y = v->by;
           z = v->bz;
           w = 1.0 / v->bw;

           v->v.x = context->ax + x * w * context->sx;
           v->v.y = context->ay - y * w * context->sy;
           v->v.z = az + z * w * context->sz;

       pointer = (UBYTE*)context->WBuffer + idx[i] * stride;
    wa = (float*)pointer;
    *wa = w;

      i++;
      } while (i < count);
   }
}

INLINE void E_ToScreen(GLcontext context, int vnum)
{
    float *wa;
    float w = 1.0/context->VertexBuffer[vnum].bw;
    UBYTE *pointer = (UBYTE*)context->WBuffer + vnum * context->ArrayPointer.texcoordstride;

    context->VertexBuffer[vnum].v.x = context->ax + context->VertexBuffer[vnum].bx * w * context->sx;
    context->VertexBuffer[vnum].v.y = context->ay - context->VertexBuffer[vnum].by * w * context->sy;
    context->VertexBuffer[vnum].v.z = context->az + context->VertexBuffer[vnum].bz * w * context->sz;

    if (context->ZOffset_State == GL_TRUE)
        context->VertexBuffer[vnum].v.z += (W3D_Float)context->ZOffset;

    context->VertexBuffer[vnum].v.w = w;

    wa = (float*)pointer;
    *wa = w;
}

#ifdef __VBCC__

#define V_ToScreen(ctx,vnum){\
static float wdiv;\
wdiv = 1.0 / ctx->VertexBuffer[vnum].bw; \
ctx->VertexBuffer[vnum].v.x = ctx->ax + ctx->VertexBuffer[vnum].bx * wdiv * ctx->sx; \
ctx->VertexBuffer[vnum].v.y = ctx->ay - ctx->VertexBuffer[vnum].by * wdiv * ctx->sy; \
ctx->VertexBuffer[vnum].v.z = ctx->az + ctx->VertexBuffer[vnum].bz * wdiv * ctx->sz; \
if (ctx->ZOffset_State == GL_TRUE) ctx->VertexBuffer[vnum].v.z += (W3D_Float)ctx->ZOffset; \
ctx->VertexBuffer[vnum].v.w = wdiv; \
}

#else

static INLINE void V_ToScreen(GLcontext context, int vnum)
{
    GLfloat wdiv = 1.f / context->VertexBuffer[vnum].bw;

    context->VertexBuffer[vnum].v.x = (W3D_Float)(context->ax + context->VertexBuffer[vnum].bx * wdiv * context->sx);

    context->VertexBuffer[vnum].v.y = (W3D_Float)(context->ay - context->VertexBuffer[vnum].by * wdiv * context->sy);

    context->VertexBuffer[vnum].v.z = (W3D_Float)(context->az + context->VertexBuffer[vnum].bz * wdiv * context->sz);

    if (context->ZOffset_State == GL_TRUE) context->VertexBuffer[vnum].v.z += (W3D_Float)context->ZOffset; \

    context->VertexBuffer[vnum].v.w = (W3D_Float)wdiv; \
}

#endif

void E_DrawPoints(GLcontext context, const int count, const UWORD *idx)
{
}

void E_DrawLines(GLcontext context, const int count, const UWORD *idx)
{
}

void E_DrawLineStrip(GLcontext context, const int count, const UWORD *idx)
{
}

void E_DrawLineLoop(GLcontext context, const int count, const UWORD *idx)
{
}

void E_DrawQuads(GLcontext context, const int count, const UWORD *idx)
{
}

void E_DrawQuadStrip(GLcontext context, const int count, const UWORD *idx)
{
}


void E_DrawTriFan(GLcontext context, const int count, UWORD *idx)
{
      int i,j;
    int size;
    ULONG and_code, or_code, guard_band;
      ULONG local_or, local_and;
      ULONG error;
      static W3D_Vertex **verts = NULL;
      static W3D_TrianglesV fan;
      static ULONG    complete[MGL_MAXVERTS];
      static GLboolean visible[MGL_MAXVERTS];
    static GLboolean projected[4096];
      int first, triangle;
      int cnum, pnum, backface, prevcopy, free;
      int sign;


    if(Clip_Volume_Bypass != GL_FALSE)
    {
       size = count;

       //first check if we are in guardband-mode
       //and discard/shrink offscreen primitives

       if((Clip_Volume_Bypass > GL_TRUE) && context->VertexBuffer[idx[0]].outcode)
       {
        i = size - 2;

        local_and = context->VertexBuffer[idx[0]].outcode & context->VertexBuffer[idx[i]].outcode & context->VertexBuffer[idx[i+1]].outcode;

        if(local_and)
        {
            i--;

            while (i)
            {
               if((local_and & context->VertexBuffer[idx[i]].outcode) == 0)
                break;
               i--;
            }
        }

        if(i == 0)
        return;

        size = i+2;
       }


       if(context->CullFace_State == GL_FALSE)
       {
        error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRIFAN, W3D_INDEX_UWORD, size, (void*)idx);
       }
       else
       {
       float fsign;
       float area;
       float x1,x2;
       float y1,y2;

       #define x(a) (context->VertexBuffer[idx[a]].bx)
       #define y(a) (context->VertexBuffer[idx[a]].by)


        first = 0;
        backface = 0;

        fsign = (float)(-context->CurrentCullSign);

        if(size == 3)
        {
            x1 = x(1) - x(0);
            y1 = y(1) - y(0);
            x2 = x(2) - x(0);
            y2 = y(2) - y(0);

            area = y2*x1 - x2*y1;
            area *= fsign;
        }
        else
        {
            float x0,y0;
            float area2;

            x0 = x(0);
            y0 = y(0);

            x1 = x(1) - x0;
             y1 = y(1) - y0;
            x2 = x(2) - x0;
            y2 = y(2) - y0;

            area = y2*x1 - x2*y1;
            area *= fsign;

            if(area < 0.f)
            {
                first++;
                area = 0.f;
            }

            i = 1;
            do
            {
                         x1 = x2;
                           y1 = y2;
                           x2 = x(i+2) - x0;
                           y2 = y(i+2) - y0;

                           area2 = y2*x1 - x2*y1;
                           area2 *= fsign;

                if(area2 < 0.f)
                {
                    if(first == i)
                        first++;
                                      else
                        backface++;
                }
                else
                {
                                    backface = 0;
                                    area += area2;
                }

            i++;
            } while (i < size-2);
        }

        if(area < context->MinTriArea)
            return;

        size -= backface + first; //shrink

        if(first)
        {
            UWORD val = idx[first];

            idx[first] = idx[0];

            error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRIFAN, W3D_INDEX_UWORD, size, (void*)&idx[first]);

            idx[first] = val;
        }
        else
        {

            error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRIFAN, W3D_INDEX_UWORD, size, (void*)idx);

        }

       #undef x
       #undef y
       }
    return;
    }

    sign = context->CurrentCullSign;

    if(context->ArrayPointer.transformed == GL_FALSE)
    {
        TransformIndex(context, count, idx);
    }


    or_code = 0;
    and_code = 0xff;

    for(i=0; i<count; i++)
    {
        and_code &= context->VertexBuffer[idx[i]].outcode;
        or_code |= context->VertexBuffer[idx[i]].outcode;
    }

    if(and_code)
        return;

    if(or_code == 0 || (or_code & context->ClipFlags))
    {
        guard_band = or_code;
    }
    else
    {
        float gcw;
        ULONG guard_code;
        MGLVertex *v;

        i = 0;
        guard_band = 0;

        do
        {
        v = &context->VertexBuffer[idx[i]];

        if(v->outcode)
        {
        gcw = v->bw * 2.0;
        guard_code = 0;

        if (-gcw > v->bx)
            guard_code |= MGL_CLIP_LEFT;
        else if (v->bx > gcw)
            guard_code |= MGL_CLIP_RIGHT;

        if (-gcw > v->by)
            guard_code |= MGL_CLIP_BOTTOM;
        else if (v->by > gcw)
            guard_code |= MGL_CLIP_TOP;

        guard_band |= guard_code;
        }

        i++;
        } while (i < count && guard_band == 0);
    }

    if (guard_band == 0)
    {
       if(context->ArrayPointer.transformed == GL_FALSE)
       E_ToScreenArray(context, count, idx);

       if(context->CullFace_State == GL_FALSE)
       {
        error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRIFAN, W3D_INDEX_UWORD, count, (void*)idx);
       }
       else
       {
       float fsign;
       float area;
       float x1,x2;
       float y1,y2;

       #define x(a) (context->VertexBuffer[idx[a]].v.x)
       #define y(a) (context->VertexBuffer[idx[a]].v.y)


        fsign = (float)(-context->CurrentCullSign);

        first = 0;
        size = count;
        backface = 0;

        if(size == 3)
        {
            x1 = x(1) - x(0);
            y1 = y(1) - y(0);
            x2 = x(2) - x(0);
            y2 = y(2) - y(0);

            area = y2*x1 - x2*y1;
            area *= fsign;
        }
        else
        {
            float x0,y0;
            float area2;

            x0 = x(0);
            y0 = y(0);

            x1 = x(1) - x0;
             y1 = y(1) - y0;
            x2 = x(2) - x0;
            y2 = y(2) - y0;

            area = y2*x1 - x2*y1;
            area *= fsign;

            if(area < 0.f)
            {
                first++;
                area = 0.f;
            }

            i = 1;
            do
            {
                         x1 = x2;
                           y1 = y2;
                           x2 = x(i+2) - x0;
                           y2 = y(i+2) - y0;

                           area2 = y2*x1 - x2*y1;
                           area2 *= fsign;

                if(area2 < 0.f)
                {
                    if(first == i)
                        first++;
                                      else
                        backface++;
                }
                else
                {
                                    backface = 0;
                                    area += area2;
                }

            i++;
            } while (i < size-2);
        }

        if(area < context->MinTriArea)
            return;

        size -= backface + first; //shrink

        if(first)
        {
            UWORD val = idx[first];

            idx[first] = idx[0];

            error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRIFAN, W3D_INDEX_UWORD, size, (void*)&idx[first]);

            idx[first] = val;
        }
        else
        {
            error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRIFAN, W3D_INDEX_UWORD, size, (void*)idx);
        }

        #undef x
        #undef y
       }

    return;
    }


        if (verts == NULL)
        {
                verts = (W3D_Vertex **)malloc(sizeof(W3D_Vertex *) * context->VertexBufferSize);
                if (!verts) return;
        }


        backface = 0;
        triangle = 0;
        i = 1;

    if(context->CullFace_State == GL_FALSE)
    {
        do
        {
                local_and = context->VertexBuffer[idx[0]].outcode
                        & context->VertexBuffer[idx[i]].outcode
                        & context->VertexBuffer[idx[i+1]].outcode;

                local_or = context->VertexBuffer[idx[0]].outcode
                        | context->VertexBuffer[idx[i]].outcode
                        | context->VertexBuffer[idx[i+1]].outcode;


                if (local_and == 0) // if the local and code is zero, we're not
                {
            complete[triangle] = local_or;
            visible[triangle] = GL_TRUE;
            backface = 0;
                }
                else
                {
                        visible[triangle] = GL_FALSE;
                        backface++;
                }
           i++;
           triangle++;
        } while ( i< count-1);
    }
    else
    {
        do
        {
                local_and = context->VertexBuffer[idx[0]].outcode
                        & context->VertexBuffer[idx[i]].outcode
                        & context->VertexBuffer[idx[i+1]].outcode;

                local_or = context->VertexBuffer[idx[0]].outcode
                        | context->VertexBuffer[idx[i]].outcode
                        | context->VertexBuffer[idx[i+1]].outcode;


                if (local_and == 0) // if the local and code is zero, we're not
                {
             complete[triangle] = local_or;

                   if(local_or & MGL_CLIP_NEGW)
                   {
                        visible[triangle] = GL_TRUE;
              backface = 0;
                   }
                   else
                   {
                        visible[triangle] = DecideFrontface(context, &(context->VertexBuffer[idx[0]]), &(context->VertexBuffer[idx[i]]), &(context->VertexBuffer[idx[i+1]]), sign);

                        if(!visible[triangle])
                backface++;
              else
                backface = 0;
                   }
                }
                else
                {
                        visible[triangle] = GL_FALSE;
                        backface++;
                }
           i++;
           triangle++;
        } while ( i< count-1);
    }

        if(backface == triangle) //early out
        return;

      size = count - backface;

       Convert(context, idx[0]);

       prevcopy = 0;
      pnum = 0;
      cnum = 0;
        free = context->VertexBufferPointer;
        triangle = 0; i = 1;

        do
        {
                if (visible[triangle] == GL_FALSE) // case 3
                {
                        triangle ++;
                        i        ++;
                }
                else
                {

                        if (complete[triangle]) // case 1
                        {
                        clip[cnum].numverts = 3;
                        clip[cnum].verts[0] = idx[0];
                        clip[cnum].verts[1] = idx[i];
                        clip[cnum].verts[2] = idx[i+1];

              if(prevcopy != i)
              Convert(context, idx[i]);

              Convert(context, idx[i+1]);
              prevcopy = i+1;

                           AE_ClipPoly(context, &clip[cnum], free, complete[triangle]);

                           if(clip[cnum].numverts)
                           {
                              free = clip[cnum].nextfree;
                              cnum++;
                           }

                           triangle++; i++;
                        }
                        else
                        {   // case 2 (the difficult part)
                        int k=3;
                        polys[pnum].verts[0] = idx[0];
                        polys[pnum].verts[1] = idx[i];
                        polys[pnum].verts[2] = idx[i+1];

                            triangle++; i++;

                            while (complete[triangle]==0 && visible[triangle] && i<size-1)
                            {
                            polys[pnum].verts[k] = idx[i+1];

                            i++; k++; triangle++;
                            }

                        polys[pnum].numverts = k;
                        pnum++;
                        }
                }
        } while (i<size-1);


//Project to screen and draw:

  if(cnum)
  {
    if(context->ArrayPointer.transformed == GL_FALSE)
    {
      for(i=0; i<size; i++)
      {
         projected[idx[i]] = GL_FALSE;
       }
    }

    for(i=context->VertexBufferPointer; i<free; i++)
    {
        V_ToScreen(context, i);
    }

  }

  if(pnum)
  {
      PolyBuffer *p;

      p = &polys[0];

    if(context->ArrayPointer.transformed == GL_FALSE)
    {
        E_ToScreen(context, p->verts[0]);
        E_ToScreen(context, p->verts[1]);
        E_ToScreen(context, p->verts[2]);

        projected[p->verts[0]] = GL_TRUE;
        projected[p->verts[1]] = GL_TRUE;
        projected[p->verts[2]] = GL_TRUE;

        if(p->numverts > 3)
        {
        i=3;
                do
                {
                        E_ToScreen(context, p->verts[i]);
                        projected[p->verts[i]] = GL_TRUE;
                i++;
                } while (i < p->numverts);
        }
    }

    error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRIFAN, W3D_INDEX_ULONG, p->numverts, (void*)p->verts);

    j = 1;
    while (j < pnum)
    {
        p = &polys[j];

        if(context->ArrayPointer.transformed == GL_FALSE)
        {
                E_ToScreen(context, p->verts[1]);
                E_ToScreen(context, p->verts[2]);

                projected[p->verts[1]] = GL_TRUE;
                projected[p->verts[2]] = GL_TRUE;


                if(p->numverts > 3)
                {
                i=3;

                   do
                   {
                        E_ToScreen(context,  p->verts[i]);
                        projected[p->verts[i]] = GL_TRUE;
                   i++;
                   } while (i < p->numverts);
                }
        }

        error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRIFAN, W3D_INDEX_ULONG, p->numverts, (void*)p->verts);

    j++;
    }
  }

  if(cnum)
  {
  fan.tex = context->w3dTexBuffer[context->CurrentBinding];
  fan.st_pattern = NULL;

    j = 0;

    do
    {
    PolyBuffer *p = &clip[j];

    if(context->ArrayPointer.transformed == GL_FALSE)
    {
        for (i=0; i<p->numverts; i++)
        {
          int vert = p->verts[i];

          verts[i] = &(context->VertexBuffer[vert].v);

          if(vert < context->VertexBufferPointer && projected[vert] == GL_FALSE)
          {
                V_ToScreen(context, vert);
                projected[vert] = GL_TRUE;
          }

        }
    }
    else
    {
        for (i=0; i<p->numverts; i++)
        {
            verts[i] = &(context->VertexBuffer[p->verts[i]].v);
        }
    }

    fan.vertexcount = p->numverts;
    fan.v = verts;
    error = W3D_DrawTriFanV(context->w3dContext, &fan);

    j++;

    } while (j < cnum);
  }
}


void E_DrawTriStrip(GLcontext context, const int count, const UWORD *idx)
{
      int i,j;
    int size;
    ULONG and_code, or_code, guard_band;
      ULONG local_or, local_and;
      ULONG error;
      static W3D_Vertex **verts = NULL;
      static W3D_TrianglesV tris;
      static ULONG    complete[MGL_MAXVERTS];
      static GLboolean visible[MGL_MAXVERTS];
    static GLboolean projected[4096];
      int first;
      int cnum, pnum, backface, prevcopy, free;


    if(Clip_Volume_Bypass != GL_FALSE)
    {
       size = count;
       first = 0;

       //first check if we are in guardband-mode
       //and discard/shrink offscreen primitives

       if((Clip_Volume_Bypass > GL_TRUE) && (context->VertexBuffer[idx[0]].outcode || context->VertexBuffer[idx[size-1]].outcode))
       {
        i = size - 3;

        local_and = context->VertexBuffer[idx[i]].outcode & context->VertexBuffer[idx[i+1]].outcode & context->VertexBuffer[idx[i+2]].outcode;

        if(local_and)
        {
            i--;

            while (i >= 0)
            {
               if((local_and & context->VertexBuffer[idx[i]].outcode) == 0)
                break;
               i--;
            }
        }

        if(i < 0)
        return;

        size = i+3;

        if(size > 3)
        {
            local_and = context->VertexBuffer[idx[0]].outcode & context->VertexBuffer[idx[1]].outcode & context->VertexBuffer[idx[2]].outcode;

            i = 2;

            if(local_and)
            {
               i++;

               while(i < size-1)
               {
                if((local_and & context->VertexBuffer[idx[i]].outcode) == 0)
                    break;
                i++;

               }
            }

            first = i-2;
        }
       }

       if(context->CullFace_State == GL_FALSE)
       {
        error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRISTRIP, W3D_INDEX_UWORD, size-first, (void*)&idx[first]);
       }
       else
       {
        float fsign;
        float area;
        float x1,x2;
        float y1,y2;

        #define x(a) (context->VertexBuffer[idx[a]].bx)
        #define y(a) (context->VertexBuffer[idx[a]].by)

        backface = 0;

        fsign = (float)(-context->CurrentCullSign);
        if(first % 2) fsign = -fsign;

                    if(size == 3)
                  {
                        x1 = x(first+1) - x(first);
                        y1 = y(first+1) - y(first);
                        x2 = x(first+2) - x(first);
                        y2 = y(first+2) - y(first);

                        area = y2*x1 - x2*y1;
                        area *= fsign;
              }
              else
              {
                  float a1,a2,b1,b2;
                  float area2;

                         i = first+1;

                        a1 = x(i);
                        b1 = y(i);
                        a2 = x(i+1);
                        b2 = y(i+1);

                        x1 = a1 - x(first);
                        y1 = b1 - y(first);
                        x2 = a2 - x(first);
                        y2 = b2 - y(first);

                        area = y2*x1 - x2*y1;
                  area *= fsign;


                           if(area < 0.f)
                           {
                                first++;
                                area = 0.f;
                           }


                            do
                           {
                           fsign = -fsign;

                           x1 = a2 - a1;
                           y1 = b2 - b1;
                           x2 = x(i+2) - a1;
                           y2 = y(i+2) - b1;
                           a1 = a2;
                          b1 = b2;
                           a2 = x(i+2);
                           b2 = y(i+2);

                           area2 = y2*x1 - x2*y1;
                           area2 *= fsign;

                              if(area2 < 0.f)
                              {
                  if(first == i)
                    first++;
                  else
                                      backface++;
                            }
                            else
                              {
                                    backface = 0;
                                    area += area2;
                              }

                           i++;
                           } while (i < size-2);

            size -= backface + first;
            }

        if(area < context->MinTriArea)
            return;

        error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRISTRIP, W3D_INDEX_UWORD, size, (void*)&idx[first]);

        #undef x
        #undef y
       }
    return;
    }


    if(context->ArrayPointer.transformed == GL_FALSE)
    {
        TransformIndex(context, count, idx);
    }

    or_code = 0;
    and_code = 0xff;

    for(i=0; i<count; i++)
    {
        and_code &= context->VertexBuffer[idx[i]].outcode;
        or_code |= context->VertexBuffer[idx[i]].outcode;
    }

    if(and_code)
        return;

    if(or_code == 0 || (or_code & context->ClipFlags))
    {
        guard_band = or_code;
    }
    else
    {
        float gcw;
        ULONG guard_code;
        MGLVertex *v;

        i = 0;
        guard_band = 0;

        do
        {
        v = &context->VertexBuffer[idx[i]];

        if(v->outcode)
        {
        gcw = v->bw * 2.0;
        guard_code = 0;

        if (-gcw > v->bx)
            guard_code |= MGL_CLIP_LEFT;
        else if (v->bx > gcw)
            guard_code |= MGL_CLIP_RIGHT;

        if (-gcw > v->by)
            guard_code |= MGL_CLIP_BOTTOM;
        else if (v->by > gcw)
            guard_code |= MGL_CLIP_TOP;

        guard_band |= guard_code;
        }

        i++;
        } while (i < count && guard_band == 0);
    }

    if (guard_band == 0)
    {
        if(context->ArrayPointer.transformed == GL_FALSE)
        E_ToScreenArray(context, count, idx);

        if(context->CullFace_State == GL_FALSE)
        {
            error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRISTRIP, W3D_INDEX_UWORD, count, (void*)idx);

        }
        else
        {
        #define x(a) (context->VertexBuffer[idx[a]].v.x)
        #define y(a) (context->VertexBuffer[idx[a]].v.y)

        float fsign;
        float area;
        float x1,x2;
        float y1,y2;

        fsign = (float)(-context->CurrentCullSign);

        size = count;
        backface = 0;
        first = 0;


                    if(size == 3)
                  {
                        x1 = x(1) - x(0);
                        y1 = y(1) - y(0);
                        x2 = x(2) - x(0);
                        y2 = y(2) - y(0);

                        area = y2*x1 - x2*y1;
                        area *= fsign;
              }
              else
              {
                  float a1,a2,b1,b2;
                  float area2;

                        a1 = x(1);
                        b1 = y(1);
                        a2 = x(2);
                        b2 = y(2);

                        x1 = a1 - x(0);
                        y1 = b1 - y(0);
                        x2 = a2 - x(0);
                        y2 = b2 - y(0);

                        area = y2*x1 - x2*y1;
                  area *= fsign;

                           if(area < 0.f)
                           {
                                first++;
                                area = 0.f;
                           }

                           i = 1;
                           do
                           {
                           fsign = -fsign;
                           x1 = a2 - a1;
                           y1 = b2 - b1;
                           x2 = x(i+2) - a1;
                           y2 = y(i+2) - b1;
                           a1 = a2;
                          b1 = b2;
                           a2 = x(i+2);
                           b2 = y(i+2);

                           area2 = y2*x1 - x2*y1;
                           area2 *= fsign;

                              if(area2 < 0.f)
                              {
                  if(first == i)
                    first++;
                  else
                                      backface++;
                            }
                            else
                              {
                                    backface = 0;
                                    area += area2;
                              }

                           i++;
                           } while (i < size-2);

            size -= first + backface;
            }

        if(area < context->MinTriArea)
            return;

        error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRISTRIP, W3D_INDEX_UWORD, size, (void*)&idx[first]);

        #undef x
        #undef y

        }

    return;
    }


    if (verts == NULL)
    {
                verts = (W3D_Vertex **)malloc(sizeof(W3D_Vertex *) * context->VertexBufferSize);
                if (!verts) return;
    }


    backface = 0;
    i = 0;

      do
      {
                local_and = context->VertexBuffer[idx[i]].outcode
                        & context->VertexBuffer[idx[i+1]].outcode
                        & context->VertexBuffer[idx[i+2]].outcode;

                local_or = context->VertexBuffer[idx[i]].outcode
                        | context->VertexBuffer[idx[i+1]].outcode
                        | context->VertexBuffer[idx[i+2]].outcode;

                if (local_and == 0) // if the local and code is zero, we're not
                {
            complete[i] = local_or;
            visible[i] = GL_TRUE;
            backface = 0;
                }
                else
                {
                        visible[i] = GL_FALSE;
                        backface++;
                }

      i++;
    } while (i < count-2);

    size = count - backface;

      free = context->VertexBufferPointer;

    prevcopy = -1;
    pnum = 0;
      cnum = 0;
      i = 0;

        do
        {
                if (visible[i] == GL_FALSE) // case 3
                {
                        i++;
                }
                else if (complete[i]) // case 1
                {
                        clip[cnum].numverts = 3;

                        clip[cnum].verts[0] = idx[i];
                        clip[cnum].verts[1] = idx[i+1];
                        clip[cnum].verts[2] = idx[i+2];

//this element is never shared with next triangle:

                        if(prevcopy == i+1)
                        {
                                Convert(context, idx[i+2]);
                        }
                        else if(prevcopy == i)
                        {
                                Convert(context, idx[i+1]);
                                Convert(context, idx[i+2]);
                        }
              else
              {
                                Convert(context, idx[i+0]);
                                Convert(context, idx[i+1]);
                                Convert(context, idx[i+2]);
              }

//this element is never shared with previous triangle:

                        prevcopy = i+2;


                        AE_ClipPoly(context, &clip[cnum], free, complete[i]);
                        i++;

                        if(clip[cnum].numverts)
                        {
                              free = clip[cnum].nextfree;
                              cnum++;
                        }
                }
                else
                {   // case 2 (the difficult part)

              int k = 3;
                        polys[pnum].verts[0] = i;
                        i++;

                        while (complete[i]==0 && visible[i] == GL_TRUE && i<size-2 && k < 64)
                        {
                                i++; k++;
                        }

                        polys[pnum].numverts = k;
                        pnum++;
                }
        } while (i < size-2);


//Project to screen and draw:

  if(cnum)
  {
    if(context->ArrayPointer.transformed == GL_FALSE)
    {
       for(i=0; i<size; i++)
       {
        projected[idx[i]] = GL_FALSE;
       }
    }

    for(i=context->VertexBufferPointer; i<free; i++)
    {
        V_ToScreen(context, i);
    }
  }

  if(pnum)
  {
    PolyBuffer *p;
    int start;

      p = &polys[0];
    start = p->verts[0];

    if(context->ArrayPointer.transformed == GL_FALSE)
    {
        E_ToScreen(context, idx[start+0]);
        E_ToScreen(context, idx[start+1]);
        E_ToScreen(context, idx[start+2]);

        projected[idx[start+0]] = GL_TRUE;
        projected[idx[start+1]] = GL_TRUE;
        projected[idx[start+2]] = GL_TRUE;

        i=3;
        while(i < p->numverts)
        {
         E_ToScreen(context, idx[start+i]);
         projected[idx[start+i]] = GL_TRUE;
        i++;
      }
      }

    error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRISTRIP, W3D_INDEX_UWORD, p->numverts, (void*)&idx[start]);

      j = 1;

      while (j < pnum)
      {
              p = &polys[j];
          start = p->verts[0];

        if(context->ArrayPointer.transformed == GL_FALSE)
        {

                if(projected[idx[start+0]] == GL_FALSE)
                E_ToScreen(context, idx[start+0]);

                E_ToScreen(context, idx[start+1]);
                E_ToScreen(context, idx[start+2]);

                projected[idx[start+0]] = GL_TRUE;
                  projected[idx[start+1]] = GL_TRUE;
                projected[idx[start+2]] = GL_TRUE;

              i=3;
                while(i < p->numverts)
                {
                        E_ToScreen(context, idx[start+i]);
                        projected[idx[start+i]] = GL_TRUE;
                i++;
                }
        }

       error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRISTRIP, W3D_INDEX_UWORD, p->numverts, (void*)&idx[start]);

    j++;
      }
  }

  if(cnum)
  {
    tris.tex = context->w3dTexBuffer[context->CurrentBinding];
    tris.st_pattern = NULL;

    j = 0;

    do
    {
    PolyBuffer *p = &clip[j];

    if(context->ArrayPointer.transformed == GL_FALSE)
    {
        for (i=0; i<p->numverts; i++)
        {
          int vert = p->verts[i];

          verts[i] = &(context->VertexBuffer[vert].v);

          if(vert < context->VertexBufferPointer && projected[vert] == GL_FALSE)
          {
                V_ToScreen(context, vert);
                projected[vert] = GL_TRUE;
          }

        }
    }
    else
    {
        for (i=0; i<p->numverts; i++)
        {
            verts[i] = &(context->VertexBuffer[p->verts[i]].v);
        }
    }

    tris.vertexcount = p->numverts;
    tris.v = verts;

    error = W3D_DrawTriFanV(context->w3dContext, &tris);

    j++;
    } while (j < cnum);
  }
}


//added 27-05-02

void E_DrawTriangles_Locked(GLcontext context, const int count, const UWORD *idx)
{
      int i, j;
    ULONG local_and, local_or;
      ULONG error;
      static W3D_Vertex **verts = NULL;
      static W3D_TrianglesV fan;
    static ULONG trichain[MGL_MAXVERTS*3];
      static int sign;
    GLboolean visible;
      int cnum, free, chainverts;

    sign = context->CurrentCullSign;

    if(Clip_Volume_Bypass != GL_FALSE)
    {
    chainverts = 0;

        if(Clip_Volume_Bypass == GL_TRUE)
        {
           if(context->CullFace_State == GL_FALSE)
           {
            error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRIANGLES, W3D_INDEX_UWORD, count, (void *)idx);
           }
           else
           {
            for(i=0; i<count; i+=3)
            {
               if(E_CheckTri(context, &context->VertexBuffer[idx[i]], &context->VertexBuffer[idx[i+1]], &context->VertexBuffer[idx[i+2]], sign) == GL_TRUE)
               {
                trichain[chainverts+0] = idx[i+0];
                trichain[chainverts+1] = idx[i+1];
                trichain[chainverts+2] = idx[i+2];
                chainverts+=3;
               }
            }

           }
        }
        else
        {
           if(context->CullFace_State == GL_FALSE)
           for(i=0; i<count; i+=3)
           {
                  local_and = context->VertexBuffer[idx[i]].outcode & context->VertexBuffer[idx[i+1]].outcode & context->VertexBuffer[idx[i+2]].outcode;

               if(local_and == 0)
               {

                trichain[chainverts+0] = idx[i+0];
                trichain[chainverts+1] = idx[i+1];
                trichain[chainverts+2] = idx[i+2];
                chainverts+=3;
               }
           }
           else
           for(i=0; i<count; i+=3)
           {
               local_and = context->VertexBuffer[idx[i]].outcode & context->VertexBuffer[idx[i+1]].outcode & context->VertexBuffer[idx[i+2]].outcode;

            if(local_and == 0)
            {

               if(E_CheckTri(context, &context->VertexBuffer[idx[i]], &context->VertexBuffer[idx[i+1]], &context->VertexBuffer[idx[i+2]], sign) == GL_TRUE)
               {
                trichain[chainverts+0] = idx[i+0];
                trichain[chainverts+1] = idx[i+1];
                trichain[chainverts+2] = idx[i+2];
                chainverts+=3;
               }
            }
           }
        }

    if(chainverts)
        error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRIANGLES, W3D_INDEX_ULONG, chainverts, (void *)trichain);

    return;
    }

    free = context->VertexBufferPointer;
    chainverts = 0;
    cnum = 0;
    i = 0;

    do
    {
       local_and = context->VertexBuffer[idx[i]].outcode & context->VertexBuffer[idx[i+1]].outcode & context->VertexBuffer[idx[i+2]].outcode;

       local_or = context->VertexBuffer[idx[i]].outcode | context->VertexBuffer[idx[i+1]].outcode | context->VertexBuffer[idx[i+2]].outcode;

       if(local_and)
       {
        i+=3;
       }
       else
       {
        if (local_or == 0)
        {
           if(context->CullFace_State == GL_FALSE)
           {
               visible = GL_TRUE;
           }
           else
           {
                     visible = E_CheckTri(context, &context->VertexBuffer[idx[i]], &context->VertexBuffer[idx[i+1]], &context->VertexBuffer[idx[i+2]], sign);
           }

                 if(visible)
                {
               trichain[chainverts+0] = idx[i+0];
               trichain[chainverts+1] = idx[i+1];
               trichain[chainverts+2] = idx[i+2];
               chainverts += 3;
           }
            }
            else
            {
               if(context->CullFace_State == GL_FALSE || (local_or & MGL_CLIP_NEGW))
               {
             visible = GL_TRUE;
                 }
           else
               {
            visible = DecideFrontface(context, &(context->VertexBuffer[idx[i]]), &(context->VertexBuffer[idx[i+1]]), &(context->VertexBuffer[idx[i+2]]), sign);
               }

               if(visible)
               {
                   Convert(context, idx[i]);
                   Convert(context, idx[i+1]);
                   Convert(context, idx[i+2]);

                   clip[cnum].numverts = 3;
                   clip[cnum].verts[0] = idx[i];
                   clip[cnum].verts[1] = idx[i+1];
                   clip[cnum].verts[2] = idx[i+2];

                   AE_ClipPoly(context, &clip[cnum], free, local_or);

                   if(clip[cnum].numverts)
                   {
            free = clip[cnum].nextfree;
            cnum++;
                   }
               }
            }
        i+=3;
        }
    } while (i < count);


    if(chainverts)
    {
        error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRIANGLES, W3D_INDEX_ULONG, chainverts, (void*)&trichain[0]);
    }


      if (cnum)
    {
    static PolyBuffer *p;
    static int start;

       if(verts == NULL)
       {
        verts = (W3D_Vertex **)malloc(sizeof(W3D_Vertex *) * context->VertexBufferSize);
                  if (!verts) return;
       }

       for(i=context->VertexBufferPointer; i<free; i++)
       {
        V_ToScreen(context, i);
       }

       fan.st_pattern = NULL;
       fan.tex = context->w3dTexBuffer[context->CurrentBinding];

       start = 0;
       i = 0;

        do
        {
           p = &clip[i];
           j = 0;

        while (j < p->numverts)
        {
            verts[start+j] = &(context->VertexBuffer[p->verts[j]].v);

            j++;
        }

        fan.v = &verts[start];
        fan.vertexcount = p->numverts;
        start += p->numverts;

        error = W3D_DrawTriFanV(context->w3dContext, &fan);
        i++;
        } while (i < cnum);
      }
}


void E_DrawTriangles(GLcontext context, const int count, const UWORD *idx)
{
      int i, j;
    ULONG local_and, local_or;
      ULONG error;
      static W3D_Vertex **verts = NULL;
      static W3D_TrianglesV fan;
    static ULONG trichain[MGL_MAXVERTS*3]; //should be enough
      static GLboolean visible;
      static int sign;
      int cnum, free, chainverts;

    if(context->ArrayPointer.transformed == GL_TRUE)
    {
        E_DrawTriangles_Locked(context, count, idx);
            return;
    }

    sign = context->CurrentCullSign;

    TransformIndex(context, count, idx);

    free = context->VertexBufferPointer;
    chainverts = 0;
    cnum = 0;
    i = 0;

    do
    {
       local_and = context->VertexBuffer[idx[i]].outcode & context->VertexBuffer[idx[i+1]].outcode & context->VertexBuffer[idx[i+2]].outcode;

       local_or = context->VertexBuffer[idx[i]].outcode | context->VertexBuffer[idx[i+1]].outcode | context->VertexBuffer[idx[i+2]].outcode;

       if(local_and)
       {
        i+=3;
       }
       else
       {
        if (local_or == 0)
        {
                 E_ToScreen(context, idx[i]);
                 E_ToScreen(context, idx[i+1]);
                 E_ToScreen(context, idx[i+2]);

           if(context->CullFace_State == GL_FALSE)
           {
               visible = GL_TRUE;
           }
           else
           {
                     visible = E_CheckTri(context, &context->VertexBuffer[idx[i]], &context->VertexBuffer[idx[i+1]], &context->VertexBuffer[idx[i+2]], sign);
           }

                 if(visible)
                {
           trichain[chainverts+0] = idx[i+0];
           trichain[chainverts+1] = idx[i+1];
           trichain[chainverts+2] = idx[i+2];
           chainverts += 3;
           }
            }
            else
            {
               if(context->CullFace_State == GL_FALSE || (local_or & MGL_CLIP_NEGW))
               {
             visible = GL_TRUE;
                 }
           else
               {
            visible = DecideFrontface(context, &(context->VertexBuffer[idx[i]]), &(context->VertexBuffer[idx[i+1]]), &(context->VertexBuffer[idx[i+2]]), sign);
               }

               if(visible)
               {
                   Convert(context, idx[i]);
                   Convert(context, idx[i+1]);
                   Convert(context, idx[i+2]);

                   clip[cnum].numverts = 3;
                   clip[cnum].verts[0] = idx[i];
                   clip[cnum].verts[1] = idx[i+1];
                   clip[cnum].verts[2] = idx[i+2];

                   AE_ClipPoly(context, &clip[cnum], free, local_or);

                   if(clip[cnum].numverts)
                   {
            free = clip[cnum].nextfree;
            cnum++;
                   }
               }
            }
        i+=3;
        }
    } while (i < count);


    if(chainverts)
    {
        error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRIANGLES, W3D_INDEX_ULONG, chainverts, (void*)&trichain[0]);
    }


      if (cnum)
    {
    static PolyBuffer *p;
    static int start;

    if(verts == NULL)
    {
        verts = (W3D_Vertex **)malloc(sizeof(W3D_Vertex *) * context->VertexBufferSize);
                  if (!verts) return;
    }

    for(i=context->VertexBufferPointer; i<free; i++)
    {
        V_ToScreen(context, i);
    }

    fan.st_pattern = NULL;
    fan.tex = context->w3dTexBuffer[context->CurrentBinding];

    start = 0;
    i = 0;

        do
        {
           p = &clip[i];
           j = 0;

           while (j < p->numverts)
           {
            int vert = p->verts[j];
            verts[start+j] = &(context->VertexBuffer[vert].v);

            if(vert < context->VertexBufferPointer)
            {
                V_ToScreen(context, vert);
            }
           j++;
           }

        fan.v = &verts[start];
        fan.vertexcount = p->numverts;

        start += p->numverts;

        error = W3D_DrawTriFanV(context->w3dContext, &fan);

        i++;
        } while (i < cnum);
      }
}

void E_DrawPolygon(GLcontext context, const int count, UWORD *idx)
{
    int i,j;
    ULONG error;
    ULONG and_code, or_code;
    PolyBuffer pclip;
      static W3D_Vertex **verts = NULL;
      static W3D_TrianglesV fan;

    if(Clip_Volume_Bypass != GL_FALSE)
    {
       int size = count;

       //first check if we are in guardband-mode
       //and discard offscreen primitives

       if((Clip_Volume_Bypass > GL_TRUE) && context->VertexBuffer[idx[0]].outcode)
       {
        ULONG local_and;

        i = size - 2;

        local_and = context->VertexBuffer[idx[0]].outcode & context->VertexBuffer[idx[i]].outcode & context->VertexBuffer[idx[i+1]].outcode;

        if(local_and)
        {
            i--;

            while (i)
            {
               if((local_and & context->VertexBuffer[idx[i]].outcode) == 0)
                break;
               i--;
            }
        }

        if(i == 0)
        return;

        size = i+2;
       }

       if(context->CullFace_State == GL_TRUE)
       {
        float x0,y0;
        float x1,y1;
        float x2,y2;
        GLfloat area;

        #define x(a) (context->VertexBuffer[idx[a]].v.x)
        #define y(a) (context->VertexBuffer[idx[a]].v.y)

        x0 = x(0);
        y0 = y(0);
        x1 = x(1) - x0;
        y1 = y(1) - y0;
        x2 = x(2) - x0;
        y2 = y(2) - y0;

        area = y2*x1 - x2*y1;

        i = 1;

        while (i < size-2)
        {
           x1 = x2;
           y1 = y2;
           x2 = x(i+2) - x0;
           y2 = y(i+2) - y0;

           area += y2*x1 - x2*y1;
           i++;
        }

        if(context->CurrentCullSign > 0)
        area = -area;

        if(area < context->MinTriArea)
        return;

        #undef x
        #undef y
       }

       error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRIFAN, W3D_INDEX_UWORD, size, (void *)idx);

    return;
    }

    if(context->ArrayPointer.transformed == GL_FALSE)
    {
        TransformIndex(context, count, idx);
    }

    or_code = 0;
    and_code = 0xff;

    for(i=0; i<count; i++)
    {
        and_code &= context->VertexBuffer[idx[i]].outcode;
        or_code |= context->VertexBuffer[idx[i]].outcode;
    }

    if(and_code)
        return;

    if (or_code == 0)
    {
       if(context->ArrayPointer.transformed == GL_FALSE)
       {
        E_ToScreenArray(context, count, idx);
       }

       if(context->CullFace_State == GL_TRUE)
       {
        float x0,y0;
        float x1,y1;
        float x2,y2;
        GLfloat area;

        #define x(a) (context->VertexBuffer[idx[a]].v.x)
        #define y(a) (context->VertexBuffer[idx[a]].v.y)

        x0 = x(0);
        y0 = y(0);
        x1 = x(1) - x0;
        y1 = y(1) - y0;
        x2 = x(2) - x0;
        y2 = y(2) - y0;

        area = y2*x1 - x2*y1;

        i = 1;

        while (i < count-2 && fabs(area) < context->MinTriArea)
        {
           x1 = x2;
           y1 = y2;
           x2 = x(i+2) - x0;
           y2 = y(i+2) - y0;

           area += y2*x1 - x2*y1;
           i++;
        }

        if(context->CurrentCullSign > 0)
        area = -area;

        if(area < context->MinTriArea)
        return;

        #undef x
        #undef y
       }

    error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRIFAN, W3D_INDEX_UWORD, count, (void *)idx);

    return;
    }

    if(verts == NULL)
    {
            verts = (W3D_Vertex **)malloc(sizeof(W3D_Vertex *) * context->VertexBufferSize);
                  if (!verts) return;
    }

    i = 0;
    do
    {
        Convert(context, idx[i]);
        pclip.verts[i] = idx[i];

    i++;
    } while (i < count);

    pclip.numverts = count;

    AE_ClipPoly(context, &pclip, context->VertexBufferPointer, or_code);

    if(pclip.numverts < 3)
        return;

    for(i=context->VertexBufferPointer; i<pclip.nextfree; i++)
    {
        V_ToScreen(context, i);
    }

    if(context->ArrayPointer.transformed == GL_FALSE)
    {
       int vert;

       i = 0;
       do
       {
        vert = pclip.verts[i];

        if(vert > context->VertexBufferPointer)
        V_ToScreen(context, vert);

        verts[i] = &(context->VertexBuffer[vert].v);

       i++;
       } while (i < pclip.numverts);
    }
    else
    {
       i = 0;
       do
       {
        verts[i] = &(context->VertexBuffer[pclip.verts[i]].v);

       i++;
       } while (i < pclip.numverts);
    }

    if(context->CullFace_State == GL_TRUE)
    {
        float x0,y0;
        float x1,y1;
        float x2,y2;
        GLfloat area;

        #define x(a) (context->VertexBuffer[pclip.verts[a]].v.x)
        #define y(a) (context->VertexBuffer[pclip.verts[a]].v.y)

        x0 = x(0);
        y0 = y(0);
        x1 = x(1) - x0;
        y1 = y(1) - y0;
        x2 = x(2) - x0;
        y2 = y(2) - y0;

        area = y2*x1 - x2*y1;

        i = 1;

        while (i < pclip.numverts-2 && fabs(area) < context->MinTriArea)
        {
           x1 = x2;
           y1 = y2;
           x2 = x(i+2) - x0;
           y2 = y(i+2) - y0;

           area += y2*x1 - x2*y1;
           i++;
        }

        if(context->CurrentCullSign > 0)
        area = -area;

        if(area < context->MinTriArea)
        return;

        #undef x
        #undef y
    }


    fan.tex = context->w3dTexBuffer[context->CurrentBinding];
    fan.st_pattern = NULL;
    fan.v = verts;
    fan.vertexcount = pclip.numverts;

    error = W3D_DrawTriFanV(context->w3dContext, &fan);
}

void E_DrawFlatFan(GLcontext context, const int count, const UWORD *idx)
{
    int i;
    int vnum;
    ULONG error;
    int Vstride;
    int Wstride;
      float *W;
      float *V;
     MGLVertex *v;

      Vstride = context->ArrayPointer.vertexstride;
      Wstride = context->ArrayPointer.texcoordstride;

     i = 0;
    do
    {
    vnum = idx[i];

      v = &context->VertexBuffer[vnum];
    V = (float*)(context->ArrayPointer.verts + vnum * Vstride);

         v->v.x = V[0];
         v->v.y = V[1];
         v->v.z = (double)V[2];

         if(context->ClientState & GLCS_TEXTURE)
         {
        W = (float*)((UBYTE*)context->WBuffer + vnum * Wstride);
              *W = 1.0;
         }

    i++;
      } while (i < count);

   error = W3D_DrawElements(context->w3dContext, W3D_PRIMITIVE_TRIFAN, W3D_INDEX_UWORD, count, (void *)idx);
}

//Range guardband-check added 18-05-02 (surgeon)

INLINE ULONG TestRangeGuardBand(GLcontext context, GLuint first, GLsizei count)
{
    int i;
    ULONG border;
    MGLVertex *v;

    v = &context->VertexBuffer[first];

    i = 0;
    border = 0;

    while (i < count && border == 0)
    {
       if(v->outcode)
       {
        float gcw = v->bw * 2.0;

        if (-gcw > v->bx)
            border |= MGL_CLIP_LEFT;
        else if (v->bx > gcw)
            border |= MGL_CLIP_RIGHT;
        if (-gcw > v->by)
            border |= MGL_CLIP_BOTTOM;
        else if (v->by > gcw)
            border |= MGL_CLIP_TOP;
       }

       i++;
       v++;
    }

    return border;
}

//FIXME: avoid redundary projections to a greater extent based on some simple statistics (on/off screen verts).

void GLLockArrays(GLcontext context, GLuint first, GLsizei count)
{
    int check_outcodes;
    ULONG offscreen;

    //pre-transform and code all verts within range:

    context->ArrayPointer.transformed = GL_TRUE;
    context->ArrayPointer.lockfirst = first;
    context->ArrayPointer.locksize  = count;

    offscreen = TransformRange(context, first, count);

    //extra test added 18-05-02:
    if(offscreen && !(offscreen & context->ClipFlags))
    {
        check_outcodes = 1;

        offscreen = TestRangeGuardBand(context, first, count);
    }
    else
    {
        check_outcodes = 0;
    }

    //project verts:

    if (offscreen)
    {
        Clip_Volume_Bypass = GL_FALSE;

        //handles fix2float if needed:

        ProjectRangeByOutcode(context, first, count);


    context->w3dContext->VPMode = W3D_VERTEX_F_F_D;
    context->w3dContext->VertexPointer = (void *)&(context->VertexBuffer[0].v.x);
    }
    else //all vertices on screen
    {
        Clip_Volume_Bypass = GL_TRUE + check_outcodes;

        ProjectRange(context, first, count);

    //we don't need to move w3d vertexpointer
     //because only the results of the projection
    //are used later on.
    //However, path needs to be seperated from standard
    //because of backface culling.
    }
}

void GLUnlockArrays(GLcontext context)
{
    context->ArrayPointer.transformed = GL_FALSE;
    context->ArrayPointer.lockfirst = 0;
    context->ArrayPointer.locksize = 0;

    if(Clip_Volume_Bypass == GL_FALSE)
    {
    context->w3dContext->VPMode = W3D_VERTEX_F_F_F;
    context->w3dContext->VertexPointer = (void *)&(context->VertexBuffer[0].bx);
    }

    Clip_Volume_Bypass = GL_FALSE;
}

static INLINE void PreDraw(GLcontext context)
{
   if (context->FogDirty && context->Fog_State)
   {
        fog_Set(context);
        context->FogDirty = GL_FALSE;
   }

   if (context->ShadeModel == GL_FLAT && context->UpdateCurrentColor == GL_TRUE)
   {
    context->UpdateCurrentColor = GL_FALSE;
    W3D_SetCurrentColor(context->w3dContext, &context->CurrentColor);
   }

#ifdef AUTOMATIC_LOCKING_ENABLE

   if (context->LockMode == MGL_LOCK_MANUAL)
        return;

   else if (context->LockMode == MGL_LOCK_AUTOMATIC) // Automatic: Lock per primitive
   {
        if (W3D_SUCCESS == W3D_LockHardware(context->w3dContext))
        {
                context->w3dLocked = GL_TRUE;
        }
        else
        {
                printf("Error during LockHardware\n");
        }
   }
   else // Smart: Lock timer based
   {
        if (context->w3dLocked == GL_FALSE)
        {
            if (W3D_SUCCESS != W3D_LockHardware(context->w3dContext))
            {
                return; // give up
            }
            context->w3dLocked = GL_TRUE;
            TMA_Start(&(context->LockTime));
        }
   }

#endif

}

static INLINE void PostDraw(GLcontext context)
{
    context->VertexBufferPointer = 0;

#ifdef AUTOMATIC_LOCKING_ENABLE

    if (context->LockMode == MGL_LOCK_SMART && TMA_Check(&(context->LockTime)) == GL_TRUE)
    {
        // Time to unlock
        W3D_UnLockHardware(context->w3dContext);
        context->w3dLocked = GL_FALSE;
    }
    else if (context->LockMode == MGL_LOCK_AUTOMATIC)
    {
         W3D_UnLockHardware(context->w3dContext);
         context->w3dLocked = GL_FALSE;
    }

#endif

}


void GLDrawElements(GLcontext context, GLenum mode, const GLsizei count, GLenum type, const GLvoid *indices)
{
   int i;
   ULONG error, prim;
   UBYTE *ub;
   ULONG *ul;
   UWORD *idx;

#ifdef VA_SANITY_CHECK
   GLboolean ShadeModel_bypass;
   GLboolean TexCoord_bypass;
#endif

   switch(type)
   {
      case GL_UNSIGNED_SHORT:
            idx = (UWORD*)indices;

    break;

      case GL_UNSIGNED_BYTE:

        ub = (UBYTE *)indices;
        idx = context->ElementIndex;

        idx[0] = ub[0];
        idx[1] = ub[1];
        idx[2] = ub[2];

        i = 3;

        while (i < count)
        {
            idx[i] = ub[i];
        i++;
        }
    break;

      case GL_UNSIGNED_INT:

        ul = (ULONG *)indices;
        idx = context->ElementIndex;

        idx[0] = ul[0];
        idx[1] = ul[1];
        idx[2] = ul[2];

        i = 3;

        while (i < count)
        {
            idx[i] = ul[i];
        i++;
        }

    break;

      default:

        GLFlagError(context, 1, GL_INVALID_ENUM);

    break;
   }

#ifdef VA_SANITY_CHECK

   ShadeModel_bypass = GL_FALSE;

   if(context->ShadeModel == GL_SMOOTH && !(context->ClientState & GLCS_COLOR))
   {
    W3D_SetState(context->w3dContext, W3D_GOURAUD, W3D_DISABLE);
    context->ShadeModel = GL_FLAT;
       ShadeModel_bypass = GL_TRUE;
   }

#endif

   PreDraw(context);

#ifdef VA_SANITY_CHECK

   TexCoord_bypass = GL_FALSE;

   if(context->Texture2D_State[0] == GL_FALSE || !(context->ClientState & GLCS_TEXTURE))
   {
      Set_W3D_Texture(context->w3dContext, 0, NULL);

    if(context->ClientState & GLCS_TEXTURE)
    {
       context->ClientState &= ~GLCS_TEXTURE;
       TexCoord_bypass = GL_TRUE;
    }
   }

#else

   if(context->Texture2D_State[0] == GL_FALSE)
   {
      Set_W3D_Texture(context->w3dContext, 0, NULL);
   }

#endif

   else
   {
        Set_W3D_Texture(context->w3dContext, 0, context->w3dTexBuffer[context->CurrentBinding]);
   }


   if(context->VertexArrayPipeline == GL_FALSE)
   {
    switch(mode)
    {
        case GL_POINTS:
        prim = W3D_PRIMITIVE_POINTS;
        break;
        case GL_LINE_STRIP:
        prim = W3D_PRIMITIVE_LINESTRIP;
        break;
        case GL_LINE_LOOP:
        prim = W3D_PRIMITIVE_LINELOOP;
        break;
        case GL_LINES:
        prim = W3D_PRIMITIVE_LINES;
        break;
        case GL_TRIANGLE_STRIP:
        prim = W3D_PRIMITIVE_TRISTRIP;
        break;
        case MGL_FLATFAN:
      case GL_POLYGON:
        case GL_TRIANGLE_FAN:
         prim = W3D_PRIMITIVE_TRIFAN;
        break;
        case GL_TRIANGLES:
        prim = W3D_PRIMITIVE_TRIANGLES;
        break;
        default:
            GLFlagError(context, 1, GL_INVALID_ENUM);
    }

    error = W3D_DrawElements(context->w3dContext, prim, W3D_INDEX_UWORD, count, (void*)&idx[0]);
   }
   else
   {

    if(context->ArrayPointer.transformed == GL_FALSE)
    {
    context->w3dContext->VPMode = W3D_VERTEX_F_F_D;
    context->w3dContext->VertexPointer = (void *)&(context->VertexBuffer[0].v.x);

    context->VertexBufferPointer = context->VertexBufferSize / 2;
    //avoid index-scan. Is this margin a safe assumption ?
    }
    else
    {
    context->VertexBufferPointer = context->ArrayPointer.lockfirst + context->ArrayPointer.locksize;
    }

#if 0
    if((count == 3) && (mode != MGL_FLATFAN))
    {
        E_DrawTriangle(context, idx);
    }
    else
#endif
    switch(mode)
    {
        case GL_TRIANGLE_STRIP:
        E_DrawTriStrip(context, count, idx);
        break;

        case GL_TRIANGLE_FAN:
        E_DrawTriFan(context, count, idx);
        break;

        case GL_TRIANGLES:
        E_DrawTriangles(context, count, idx);
        break;

        case GL_POLYGON:
        E_DrawPolygon(context, count, idx);
        break;

        case MGL_FLATFAN:
        E_DrawFlatFan(context, count, idx);
        break;

        default:
        GLFlagError(context, 1, GL_INVALID_ENUM);
    }

    if(context->ArrayPointer.transformed == GL_FALSE)
    {
    context->w3dContext->VPMode = W3D_VERTEX_F_F_F;
    context->w3dContext->VertexPointer = (void *)&(context->VertexBuffer[0].bx);
    }
   }

   PostDraw(context);

#ifdef VA_SANITY_CHECK

   if(ShadeModel_bypass == GL_TRUE)
   {
    W3D_SetState(context->w3dContext, W3D_GOURAUD, W3D_ENABLE);
    context->ShadeModel = GL_SMOOTH;
   }

   if(TexCoord_bypass == GL_TRUE)
   {
    context->ClientState |= GLCS_TEXTURE;
   }

#endif

}

#ifdef __VBCC__
#undef V_ToScreen
#endif